<template>
  <div class="box" ref="chartDom"></div>
</template>
<script lang="ts" setup>
import * as echarts from 'echarts'
import { onMounted, ref } from 'vue'

const chartDom = ref<HTMLElement | null>(null)

const initChart = () => {
  const myChart = echarts.init(chartDom.value)
  const textColor = 'rgba(37, 76, 112, 1)'
  const optionsData:any = [
    {
      name: 'ICT',
      icon: 'circle',
      value: 94,
      than: '50%',
      textStyle: {
        color: '#22a9fe'
      },
      itemStyle: {
        color: '#22a9fe'
      }
    },

    {
      name: '网络工程师',
      icon: 'circle',
      value: 47,
      than: '20%',
      textStyle: {
        color: '#2dde4b'
      },
      itemStyle: {
        color: '#2dde4b'
      }
    },
    {
      name: 'IT',
      value: 31,
      icon: 'circle',
      than: '20%',
      textStyle: {
        color: '#e02b41'
      },
      itemStyle: {
        color: '#e02b41'
      }
    },
    {
      name: '网规网优',
      value: 51,
      icon: 'circle',
      than: '10%',
      textStyle: {
        color: '#f4cf4d'
      },
      itemStyle: {
        color: '#f4cf4d'
      }
    },
    {
      name: '管理岗位',
      value: 51,
      icon: 'circle',
      than: '10%',
      textStyle: {
        color: 'blue'
      },
      itemStyle: {
        color: 'blue'
      }
    }
  ]
  window.addEventListener('resize', () => {
    myChart.resize()
  })
  function getParametricEquation(startRatio, endRatio, isSelected, isHovered, k, height) {
    // 计算
    let midRatio = (startRatio + endRatio) / 2

    let startRadian = startRatio * Math.PI * 2
    let endRadian = endRatio * Math.PI * 2
    let midRadian = midRatio * Math.PI * 2

    // 如果只有一个扇形，则不实现选中效果。
    if (startRatio === 0 && endRatio === 1) {
      isSelected = false
    }

    // 通过扇形内径/外径的值，换算出辅助参数 k（默认值 1/3）
    k = typeof k !== 'undefined' ? k : 1 / 3

    // 计算选中效果分别在 x 轴、y 轴方向上的位移（未选中，则位移均为 0）
    let offsetX = isSelected ? Math.cos(midRadian) * 0.1 : 0
    let offsetY = isSelected ? Math.sin(midRadian) * 0.1 : 0

    // 计算高亮效果的放大比例（未高亮，则比例为 1）
    let hoverRate = isHovered ? 1.05 : 1

    // 返回曲面参数方程
    return {
      u: {
        min: -Math.PI,
        max: Math.PI * 3,
        step: Math.PI / 32
      },

      v: {
        min: 0,
        max: Math.PI * 2,
        step: Math.PI / 20
      },

      x: function (u, v) {
        if (u < startRadian) {
          return offsetX + Math.cos(startRadian) * (1 + Math.cos(v) * k) * hoverRate
        }
        if (u > endRadian) {
          return offsetX + Math.cos(endRadian) * (1 + Math.cos(v) * k) * hoverRate
        }
        return offsetX + Math.cos(u) * (1 + Math.cos(v) * k) * hoverRate
      },

      y: function (u, v) {
        if (u < startRadian) {
          return offsetY + Math.sin(startRadian) * (1 + Math.cos(v) * k) * hoverRate
        }
        if (u > endRadian) {
          return offsetY + Math.sin(endRadian) * (1 + Math.cos(v) * k) * hoverRate
        }
        return offsetY + Math.sin(u) * (1 + Math.cos(v) * k) * hoverRate
      },

      z: function (u, v) {
        if (u < -Math.PI * 0.5) {
          return Math.sin(u)
        }
        if (u > Math.PI * 2.5) {
          return Math.sin(u)
        }
        return Math.sin(v) > 0 ? 1 * height : -1
      }
    }
  }

  // 生成模拟 3D 饼图的配置项
  function getPie3D(pieData, internalDiameterRatio) {
    let series: any = []
    let sumValue = 0
    let startValue = 0
    let endValue = 0
    let legendData: any = []
    let k =
      typeof internalDiameterRatio !== 'undefined'
        ? (1 - internalDiameterRatio) / (1 + internalDiameterRatio)
        : 1 / 3

    // 为每一个饼图数据，生成一个 series-surface 配置
    for (let i = 0; i < pieData.length; i++) {
      sumValue += pieData[i].value

      let seriesItem: any = {
        name: typeof pieData[i].name === 'undefined' ? `series${i}` : pieData[i].name,
        type: 'surface',
        parametric: true,
        wireframe: {
          show: false
        },
        pieData: pieData[i],
        pieStatus: {
          selected: false,
          hovered: false,
          k: k
        }
      }

      if (typeof pieData[i].itemStyle != 'undefined') {
        let itemStyle: any = {}

        typeof pieData[i].itemStyle.color != 'undefined'
          ? (itemStyle.color = pieData[i].itemStyle.color)
          : null
        typeof pieData[i].itemStyle.opacity != 'undefined'
          ? (itemStyle.opacity = pieData[i].itemStyle.opacity)
          : null

        seriesItem.itemStyle = itemStyle
      }
      series.push(seriesItem)
    }

    // 使用上一次遍历时，计算出的数据和 sumValue，调用 getParametricEquation 函数，
    // 向每个 series-surface 传入不同的参数方程 series-surface.parametricEquation，也就是实现每一个扇形。
    for (let i = 0; i < series.length; i++) {
      endValue = startValue + series[i].pieData.value
      series[i].pieData.startRatio = startValue / sumValue
      series[i].pieData.endRatio = endValue / sumValue
      series[i].parametricEquation = getParametricEquation(
        series[i].pieData.startRatio,
        series[i].pieData.endRatio,
        false,
        false,
        k,
        series[i].pieData.value
      )
      startValue = endValue
      legendData.push(series[i].name)
    }
    return series
  }

  const series = getPie3D(optionsData, 0)
  // 准备待返回的配置项，把准备好的 legendData、series 传入。
  const option = {
    legend: {
      show: true,
      icon: 'circle',
      bottom: '-3%',
      itemWidth: 5,
      itemHeight: 5,
      formatter: function (name) {
        const than = optionsData.find((item) => item.name === name).than
        return `{name|${name}}\n{than|${than}}
        `
      },
      data: optionsData.map((dItem) => {
        return {
          ...dItem,
          textStyle: {
            rich: {
              name: {
                color: textColor
              },
              than: {
                color: dItem.textStyle.color,
                padding: [5, 0, 0, 0]
              }
            }
          }
        }
      }),
      tooltip: {
        show: true
      }
    },
    tooltip: {
      show: true,
      formatter: (params) => {
        if (params.seriesName !== 'mouseoutSeries' && params.seriesName !== 'pie2d') {
          return `${
            params.seriesName
          }<br/><span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${
            params.color
          };"></span>${option.series[params.seriesIndex].pieData.value + '人'}`
        }
      }
    },
    labelLine: {
      show: false
    },
    label: {
      show: false
    },
    xAxis3D: {
      min: -1,
      max: 1
    },
    yAxis3D: {
      min: -1,
      max: 1
    },
    zAxis3D: {
      min: -1,
      max: 1
    },
    grid3D: {
      show: false,
      boxHeight: 1,
      top: '-10%',
      viewControl: {
        distance: 250,
        alpha: 30,
        beta: 60,
        zoomSensitivity: 0,
        autoRotate: true // 自动旋转
      }
    },

    series: series
  }
  myChart.setOption(option)
}

onMounted(() => {
  initChart()
})
</script>
<style lang="less" scoped>
.box {
  width: 100%;
  height: 100%;
}
</style>